TypeRefs can have several representations for logically the
same type, so they don't make good keys.

Also, delete unused `uncheckedStableClassRef` entry.

Can't be a lazy val, because one of the symbols it tests
(`newRefArray`) can be recomputed.

Remve versions in Symbols, always go through version in
Denotations. Avoids having two equivalent ways to do the same thing.

Was a lazy val, but this is not stable under recompilation.

Maps should not have TypeRefs as keys, yet symbols are not stable
for recompilation. Solution: Construct these maps over symbols but
move them to CapturedVars#Transform where they will be re-built
on each run.

Remove unneeded maps and make the ones that are needed
private. Reason: Maps indexed with TypeNames are prone
to misuse; should be accessed only with names of known
primitive classes.

Contains tests on thsoe sets would be flakey anyway.

1) Have symbol sets cached per run
2) Use methods Denotation#isPrimitiveValueClass, Denotation#isNumericValueClass
instead of calling contains directly on symbol sets.

TypeRef becomes Type, thus removing duplicates. Where
...Type was used in an extraction (e.g. ArrayType(...),
FunctionType(...)), we now use ...Of.

Since we now have two forms of (almost) everything in Definitions,
might as well profit from it.

Now also provides compilation unit.

Track starts and ends of completions using indentation.

Forces a bit less, and could be more efficient.
Did not seem to make a difference with current
CyclicReferences though, except that cyclic
error happened a bit later in the sequence.

Set info early in order to avoid cyclic reference errors.
Errors were observed when compiling

    scala/Predef.scala scala/package.scala scala/collection/GenSeqLike.scala